类加载器的主要作用就是加载 Java 类的字节码（ .class 文件）到 JVM 中（在内存中生成一个代表该类的 Class 对象）。 字节码可以是 Java 源程序（.java文件）经过 javac 编译得来，也可以是通过工具动态生成或者通过网络下载得来。

线程私有的:

• 程序计数器
• 虚拟机栈
• 本地方法栈

线程共享的：

• 堆
• 方法区
• 直接内存

用来执行方法区中的字节码指令

public class TestFrame{//1
    
    public static void main(String []args){   //2     
        method1(10);//3
    }
    private static void method1(int x){//4
        
        int y = x + 1;//5
        Object m = method2();//6
        System.out.println(m);//7
    }
    private static Object method2(){//8
        
        Object n = new Object();//9
        return n;//10
    }
}
复制

• 第一行，java虚拟机会先进行类加载，将类中的字节码加到java的虚拟机中，也就是方法区。
• 类加载完，java虚拟机就会启动一个为main的主线程，并且为这个线程分配一个栈内存，然后线程就交给任务调度器去执行。当cpu为主线程分配了时间片，cpu就开始运行主线程，运行到哪行代码由程序计数器来记录。

• 第二行：入口是main方法，则虚拟机会为main方法创建一个栈帧。

• 第三行：进入method1方法，也会为method1方法创建一个栈帧。x=10写进栈帧。

• 第五行：执行完后y = 11;
• 第六行：进入method2方法，同时为method2方法创建一个栈帧。

• 第九行：在堆中新建一个对象，并将对象的引用n指向对象。

  

• 第10行：返回n,并将m指向object对象。

• 之后释放method2的栈帧内存。返回到method1,之后method1执行完，其栈帧也要释放掉。

1. 类加载检查（先判断有没有加载过）

   虚拟机遇到一个new指令，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已经被加载过，解析和初始化过，如果没有，那必须先执行响应的类加载过程。

2. 分配内存（没有加载过就为对象在堆中分配内存）

   在类加载检查通过后，接下来虚拟机将会为新生对象分配内存。对象所需的内存大小在类加载完成后便可确认，为对象分配空间的任务等同于把一块确定大小的内存从java堆中划分出来。分类方式有指针碰撞和空闲列表方式，选择哪种分配方式是由java堆是否规整决定的，而java堆是否规整又有采用的垃圾收集器是否带有压缩整理功能决定。

   HotSpot虚拟机内存分配的两种方式

   1. 指针碰撞

   • 适用场合:堆内存规整(即没有内存碎片);
   • 用过的内存全部整合到一边，没有用过的内存放在另一边，中间有一个分界值指针，只需要向着没有用过的内存方向将该指针移动对象内存大小位置即可。
   • GC收集器：Serial,ParNew

   2. 空闲列表

   • 适合用于堆内存不规整的情况;

   • 虚拟机会维护一个列表，该列表会记录哪些内存块是可用的，在分配的时候，找一块足够大的内存块来分配给对象实例，最后更新列表记录.

   • GC收集器：CMS

     HotSpot虚拟机内存分配的并发问题

     在创建对象的时候有一个很重要的问题，就是线程安全，因为在实际开发过程中，创建对象是很频繁的事情，作为虚拟机来说，必须要保证线程是安全的，通常来讲，虚拟机采用两种方式来保证线程安全：

     • CAS+失败重试： CAS 是乐观锁的一种实现方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。虚拟机采用 CAS 配上失败重试的方式保证更新操作的原子性。
     • 线程本地分配缓存区(TLAB): 为每一个线程预先在 Eden 区分配一块儿内存，JVM 在给线程中的对象分配内存时，首先在 TLAB 分配，当对象大于 TLAB 中的剩余内存或 TLAB 的内存已用尽时，再采用上述的 CAS 进行内存分配

     ---

3. 初始化零值

   内存分配完后，虚拟机需要将分配到的内存空间都初始化为零值(不包括对象头)，这一步操作保证了对象实例字段在java代码中可以不赋初始值就可以使用，程序能访问到这些字段的数据类型所对应的零值。

4. 设置对象头

   初始化零值后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例，如果才能找到类的元数据信息，对象的哈希码，对象的GC分代年龄等信息。这些信息存放在对象头中。另外根据虚拟机当前运行状态的不同，如是否用偏向锁等，对象头会有不同的设置方式。

5. 执行方法

   new指令之后会接着执行方法，按照程序员的意愿对对象进行初始化，这样一个真正可用的对象才完全被构造出来。

   在上面工作都完成之后，从虚拟机的视角，一个对象已经产生了，但是从java程序视角来看，构造函数，即class文件中的方法还没有执行，所有的字段都为默认的零值，对象需要的其他资源和状态信息也还没有按照预定的意图构造好。

在hotSpot虚拟机中，对象在内存中的布局可以分为3块区域：对象头，实例数据和对齐填充。

• 对象头：包含两部分信息，第一部分用于存储对象自身的运行时数据（哈希码，GC分代年龄，锁状态标志等），另一部分是类型指针，即对象指向它的类型元数据的指针，java虚拟机通过这个指针来确定该对象是哪个类的实例。
• 实例数据：是对象真正存储的有效信息，也是在程序中所定义的各种类型的字段内容。
• 对齐填充：没有特别的含义，只起占位作用。因为 Hotspot 虚拟机的自动内存管理系统要求对象起始地址必须是 8 字节的整数倍，换句话说就是对象的大小必须是 8 字节的整数倍。而对象头部分正好是 8 字节的倍数（1 倍或 2 倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。

• java程序通过栈上的reference数据来操作堆上的具体对象，对象的访问方式由虚拟机实现而定，目前主流的访问方式由使用句柄和直接指针两种。

• 这两种对象访问方式各有优势，使用句柄来访问的最大好处是reference中存储的是稳定的句柄地址，在对象被移动时只会改变句柄中的实例数据指针，而reference本身不需要修改。使用直接指针访问的最大好处就是速度快，它节省了一次指针定位的时间开销。

1. 句柄： 如果使用句柄的化，java堆中会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据域类型数据各自的具体地址信息。

   “.\images\对象的访问定位-使用句柄.png” could not be found.

2. 直接指针：如果使用直接指针访问，那么java堆对象的布局就必须考虑如何放置访问类型数据的相关信息，而reference中存储的直接就是对象的地址。

1. 引用计数法

• 给对象添加一个引用计数器，每当有一个地方引用他，计数器就加1，当引用失效，计数器就间1，当计数器为0时对象就是不可用的了。
• 这个方法实现简单，效率高，但是很难解决对象之间相互循环引用的问题。

2. 可达性分析算法

• 基本思想就是通过一系列的"GC Roots"的对象作为起点，从这个节点开始向下搜索，节点所走过的路径称为引用链，当一个对象GC Roots没有任何引用链相连的话，则证明对象是不可用的。
• GCRoot
  • 虚拟机栈（栈帧中的本地变量表）中引用的对象。
  • 方法区中类静态属性引用的对象
  • 方法区中常量引用的对象
  • 本地方法栈中JNI（即一般说的Native方法）引用的对象

3. 方法区的回收

   因为方法区主要存放永久代对象，而永久代对象的回收率比新生代低很多，所以在方法区上进行回收性价比不高。

   主要是对常量池的回收和对类的卸载。

   为了避免内存溢出，在大量使用反射和动态代理的场景都需要虚拟机具备类卸载功能。

   类的卸载条件很多，需要满足以下三个条件，并且满足了条件也不一定会被卸载：

   • 该类所有的实例都已经被回收，此时堆中不存在该类的任何实例。
   • 加载该类的 ClassLoader 已经被回收。
   • 该类对应的 Class 对象没有在任何地方被引用，也就无法在任何地方通过反射访问该类方法

引用本身也是一种对象

软引用：List<SoftReference<byte[]>> list=new ArrayLIst<>();

​ SoftReference<byte[]> ref = new SoftReference<>(new byte[1024])

​ list.add(ref);

在这里list 强引用SoftReference对象，然后通过SoftReference间接引用byte数组。

1. 强引用：对于强引用，垃圾回收器绝对不会回收它(即使内存不足)。只有GC Root都不引用该对象时，才会回收强引用对象。

2. 软引用：当GC Root指向软引用对象时，在内存不足时，会回收软引用所引用的对象。但是软引用本身不会被清理。如果想要清理软引用，需要使用引用队列。大概思路为：查看引用队列中有无软引用，如果有，则将该软引用从存放它的集合中移除（这里为一个list集合。图片缓存框架中，“内存缓存”中的图片是以这种引用保存，使得 JVM 在发生 OOM 之前，可以回收这部分缓存。

   //软引用
   public class Demo1 {
   	public static void main(String[] args) {
   		final int _4M = 4*1024*1024;
   		//使用软引用对象 list强引用SoftReference，而SoftReference和byte数组则是软引用
   		List<SoftReference<byte[]>> list = new ArrayList<>();
   		SoftReference<byte[]> ref= new SoftReference<>(new byte[_4M]);
   	}
   }
   //清理软引用需要使用引用队列
   public class Demo1 {
   	public static void main(String[] args) {
   		final int _4M = 4*1024*1024;
   		//使用引用队列，用于移除引用为空的软引用对象
   		ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
   		//使用软引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是软引用
   		List<SoftReference<byte[]>> list = new ArrayList<>();
   		SoftReference<byte[]> ref= new SoftReference<>(new byte[_4M]);
   
   		//遍历引用队列，如果有元素，则移除
   		Reference<? extends byte[]> poll = queue.poll();
   		while(poll != null) {
   			//引用队列不为空，则从集合中移除该元素
   			list.remove(poll);
   			//移动到引用队列中的下一个元素
   			poll = queue.poll();
   		}
   	}
   }
   复制

3. 弱引用：只有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用所引用的对象。如上图如果B对象不再引用A3对象，则A3对象会被回收。弱引用的使用和软引用类似，只是将 SoftReference 换为了 WeakReference。

4. 虚引用：如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。当虚引用对象所引用的对象被回收以后，虚引用对象就会被放入引用队列中。

   • 虚引用的一个体现是释放直接内存所分配的内存，当引用的对象ByteBuffer被垃圾回收以后，虚引用对象Cleaner就会被放入引用队列中，然后调用Cleaner的clean方法来释放直接内存。
   • 如上图，B对象不再引用ByteBuffer对象，ByteBuffer就会被回收。但是直接内存中的内存还未被回收。这时需要将虚引用对象Cleaner放入引用队列中，然后调用它的clean方法来释放直接内存
5. 终结器引用：所有的类都继承自Object类，Object类有一个finalize方法。当某个对象不再被其他的对象所引用时，会先将终结器引用对象放入引用队列中，然后根据终结器引用对象找到它所引用的对象，然后调用该对象的finalize方法。调用以后，该对象就可以被垃圾回收了。

   • 如上图，B对象不再引用A4对象。这是终结器对象就会被放入引用队列中，引用队列会根据它，找到它所引用的对象。然后调用被引用对象的finalize方法。调用以后，该对象就可以被垃圾回收了。

引用队列

• 软引用和弱引用可以配合引用队列：在弱引用和虚引用所引用的对象被回收以后，会将这些引用放入引用队列中，方便一起回收这些软/弱引用对象。
• 虚引用和终结器引用必须配合引用队列：虚引用和终结器引用在使用时会关联一个引用队列。

1. 标记清除算法： 在标记阶段，程序会检查每个对象是否为活动对象，如果是活动对象，则程序会在对象头部打上标记。在清除阶段，会进行对象回收并取消标志位，另外，还会判断回收后的分块与前一个空闲分块是否连续，若连续，会合并这两个分块。回收对象就是把对象作为分块，连接到被称为 “空闲链表” 的单向链表，之后进行分配时只需要遍历这个空闲链表，就可以找到分块。

   • 优点: 对象不需要移动，只操作不存活对象，存活对象多的时候不影响效率。
   • 缺点： 执行效率不稳定，执行效率随着对象数量的增长而降低。空间问题，标记清除后会产生大量的不连续的碎片。
   • 适合: 存活比例高的，希望暂停时间尽可能短的。
2. 标记复制算法：将内存分为大小相同的两块，每次使用其中的一块，当这一块的内存使用完后，就将还存活的对象复制到另外一块去，然后把使用的空间一次清理掉。

   • 优点： 无碎片，标记和复制可以同时进行，每次只对一块内存进行回收，高效，实现简单。
   • 缺点： 额外空间，空间利用率低；需要暂停。
   • 适合： 存活比例少，回收不频繁，内存申请次数多
3. 标记整理算法: 让存活的对象向一端移动，直接清理掉端边界以外的内存。

   • 优点： 无碎片，内存分配更加快速，空闲大小和位置便于统计。
   • 缺点： 因为要移动存活的变量，和重新引用赋值， 就需要执行暂停，使得GC时间延长。
   • 适合： 存活比例高，回收不频繁

4. 分代收集算法

• 对于新生代，可以选择标记复制.
• 对于老年代，可以选择标记清除或者标记整理。
• 流程：
  • 新创建的对象都被放在了新生代的伊甸园中。
  • 当伊甸园中的内存不足时，就会进行一次垃圾回收，这时的回收叫做 Minor GC（会触发 stop the world， 暂停其他用户线程，只让垃圾回收线程工作）。
  • Minor GC 会将伊甸园和幸存区FROM存活的对象先复制到 幸存区 TO中， 并让其寿命加1，再交换两个幸存区。
  • 再次创建对象，若新生代的伊甸园又满了，则会再次触发 Minor GC，这时不仅会回收伊甸园中的垃圾，还会回收幸存区中的垃圾，再将活跃对象复制到幸存区TO中。回收以后会交换两个幸存区，并让幸存区中的对象寿命加1。(也就是保证To区是空的。)
  • 如果幸存区中的对象的寿命超过某个阈值（最大为15，4bit），就会被放入老年代中。
  • 如果新生代老年代中的内存都满了，就会先触发Minor GC，如果之后内存还是不足。再触发Full GC，扫描新生代和老年代中所有不再使用的对象并回收。

• 并行收集：指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态。
• 并发收集：指用户线程与垃圾收集线程同时工作（不一定是并行的可能会交替执行）。用户程序在继续运行，而垃圾收集程序运行在另一个CPU上。
• 吞吐量：即CPU用于运行用户代码的时间与CPU总消耗时间的比值（吞吐量 = 运行用户代码时间 / ( 运行用户代码时间 + 垃圾收集时间 )），也就是。例如：虚拟机共运行100分钟，垃圾收集器花掉1分钟，那么吞吐量就是99%
• 串行
  • 单线程
  • 内存较小，个人电脑（CPU核数较少）
• 吞吐量优先：
  • 多线程
  • 堆内存较大，多核cpu
  • 让单位时间内STW时间短 单次0.2秒，比0.1s多，但是总共花的时间少一共0.2s
• 响应时间优先：
  • 多线程
  • 堆内存较大, 多核cpu
  • 尽可能让单次STW的时间最短 单次0.1s ，有三次 也就是一共0.3s

• SerialGC
  • 新生代内存不足垃圾回收 minorGC
  • 老年代内存不足垃圾回收 FullGC
• ParallelGC
  • 新生代内存不足垃圾回收 minorGC
  • 老年代内存不足垃圾回收 FullGC
• CMS
  • 新生代内存不足垃圾回收 minorGC
  • 老年代内存不足
    • 并发失败后，会进行Full GC
• G1
  • 新生代内存不足垃圾回收 minorGC
  • 老年代内存不足（老年代所占内存超过阈值）
    • 如果垃圾产生速度慢于垃圾回收速度，不会触发Full GC，还是并发地进行清理
    • 如果垃圾产生速度快于垃圾回收速度，便会触发Full GC

• Minor GC：回收新生代，因为新生代对象存活时间很短，因此 Minor GC 会频繁执行，执行的速度一般也会比较快。
• Full GC：回收老年代和新生代，老年代对象其存活时间长，因此 Full GC 很少执行，执行速度会比 Minor GC 慢很多。

1. 对象优先在 Eden 分配

大多数情况下，对象在新生代 Eden 上分配，当 Eden 空间不够时，发起 Minor GC。

2. 大对象直接进入老年代

大对象是指需要连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组。

经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配给大对象。

-XX:PretenureSizeThreshold，大于此值的对象直接在老年代分配，避免在 Eden 和 Survivor 之间的大量内存复制、

3. 长期存活的对象进入老年代

为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，增加到一定年龄则移动到老年代中。

-XX:MaxTenuringThreshold 用来定义年龄的阈值

4. 动态对象年龄判定

虚拟机并不是永远要求对象的年龄必须达到 MaxTenuringThreshold 才能晋升老年代，如果在 Survivor 中相同年龄所有对象大小的总和大于 Survivor 空间的一半，则年龄大于或等于该年龄的对象可以直接进入老年代，无需等到 MaxTenuringThreshold 中要求的年龄。

5. 空间分配担保

在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。

如果不成立的话虚拟机会查看 HandlePromotionFailure 的值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 的值不允许冒险，那么就要进行一次 Full GC。

对于 Minor GC，其触发条件非常简单，当 Eden 空间满时，就将触发一次 Minor GC。而 Full GC 则相对复杂，有以下条件：

1. 调用 System.gc()

只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存.

2. 老年代空间不足

老年代空间不足的常见场景为前文所讲的大对象直接进入老年代、长期存活的对象进入老年代等。

为了避免以上原因引起的 Full GC，应当尽量不要创建过大的对象以及数组。除此之外，可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在新生代被回收掉，不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄，让对象在新生代多存活一段时间。

3. 空间分配担保失败

在发生 Minor GC 之前，虚拟机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话，那么 Minor GC 可以确认是安全的。

如果不成立的话虚拟机会查看 HandlePromotionFailure 的值是否允许担保失败，如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 的值不允许冒险，那么就要进行一次 Full GC。

4. JDK 1.7 及以前的永久代空间不足

在 JDK 1.7 及以前，HotSpot 虚拟机中的方法区是用永久代实现的，永久代中存放的为一些 Class 的信息、常量、静态变量等数据。

当系统中要加载的类、反射的类和调用的方法较多时，永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC。如果经过 Full GC 仍然回收不了，那么虚拟机会抛出 java.lang.OutOfMemoryError。

为避免以上原因引起的 Full GC，可采用的方法为增大永久代空间或转为使用 CMS GC。

5. Concurrent Mode Failure

执行 CMS GC 的过程中同时有对象要放入老年代，而此时老年代空间不足（可能是 GC 过程中浮动垃圾过多导致暂时性的空间不足），便会报 Concurrent Mode Failure 错误，并触发 Full GC。

java的常量池有三种，即字符串常量池，class常量池，运行时常量池。

1. class常量池：我们写的每一个java类被编译之后都会生成一个对应的class文件。class文件中除了有类的版本，字段方法，接口等描述信息外，还有一项信息时常量池，用于存放编译期生成的各种字面量和符号引用。每个类都有一个class常量池。

   什么时字面量和符号引用？

   字面量比较接近于java语言层面的常量概念，如文本字符串，声明为final的常量值和8种基本类型的变量，而符号引用则属于编译原理方面的概念，包括三类变量:类和接口的全限定名。字段的名称和描述符。方法的名称和描述符

2. 字符串常量池

   • 为字符串开辟一个字符串常量池，类似于缓存区。
   • 创建字符串常量时，首先检查字符串常量池是否存在该字符串
   • 若存在该字符串，返回引用实例；若不存在，实例化该字符串并放入池中
   • 在JDK1.6之前，字符串常量池在方法区，在JDK1.7，字符串常量池被移入了堆中。移入堆中的原因大概是方法区的内存空间太小了。
3. 运行时常量池

   • 运行时常量池存在于内存中的方法区，class常量池被加载到内存之后会存放在运行时常量池中。除了保存Class文件中描述的符号引用外，还会把符号引用翻译为直接引用，并存储在运行时常量池中。
   

string类对象创建的两种方式:

String str1='abcd';//先检查字符串常量池中有没有‘abcd’，如果没有，则创建一个，然后str1指向字符串常量池中的对象，如果有，直接将str1指向‘abcd’
String str2=new String("abcd");//堆中创建一个新对象
String str3=new String("abcd");//堆中创建一个新对象
System.out.println(str1==str2);//false
System.out.println(str1==str2);//false
复制

这两种不同的创建方法是有差别的。

• 第一种方式是在常量池中拿对象；
• 第二种方式是直接在堆内存空间创建一个新的对象。

String类的常量池比较特殊，它的主要使用方法有两种：

• 直接使用双引号声明出来的String对象会直接存储在常量池中。
• 如果不是双引号声明的String对象，可以使用String使用的intern方法。String.intern()是一个Native方法，它的作用是：如果运行时常量池中已经包含了一个等于String对象内容的字符串，则返回常量池中该字符串的引用；如果没有，JDK1.7之前（不包含1.7）的处理方式是在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用，JDK1.7以及之后的处理方式是在常量池中记录此字符串的引用，并返回该引用。

          String s1 = new String("计算机");
          String s2 = s1.intern();
          String s3 = "计算机";
          System.out.println(s2);//计算机
          System.out.println(s1 == s2);//false，因为一个是堆内存中的 String 对象一个是常量池中的 String 对象，
          System.out.println(s3 == s2);//true，因为两个都是常量池中的 String 对象

复制

字符串拼接

• 尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用StrnigBuilder或者StringBuffer.

String str1="str";
String str2="ing";

String str3="str"+"ing";//常量池中的对象
String str4=str1+str2;//在堆上创建的新的对象
String str5="string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false
复制

将创建一个或者两个字符串。

• 创建一个名为s1的变量(引用)；
• 如果String 池中没有"abc"存在，则在String池中创建一个String类型的"abc"，有就不创建；
• 使用new关键字在堆中创建一个String对象
• 将new创建的string对象的地址赋给s1

Java 虚拟机所管理的内存中最大的一块，Java 堆是所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数组都在这里分配内存。

• 显式指定堆内存–Xms和-Xmx

-Xms<heap size>[unit]
-Xmx<heap size>[unit]
举个栗子 🌰，如果我们要为 JVM 分配最小 2 GB 和最大 5 GB 的堆内存大小，我们的参数应该这样来写：
-Xms2G -Xmx5G
复制

• 显式新生代内存(Young Generation)

  • 通过-XX:NewSize和-XX:MaxNewSize指定

    -XX:NewSize=<young size>[unit]
    -XX:MaxNewSize=<young size>[unit]
    
    举个栗子 🌰，如果我们要为 新生代分配 最小 256m 的内存，最大 1024m 的内存我们的参数应该这样来写：
    -XX:NewSize=256m
    -XX:MaxNewSize=1024m
    复制

  • 通过-Xmn<young size>[unit]指定

    举个栗子 🌰，如果我们要为 新生代分配 256m 的内存（NewSize 与 MaxNewSize 设为一致），我们的参数应该这样来写：
    -Xmn256m
    复制

• 通过 -XX:NewRatio=<int> 来设置老年代与新生代内存的比值。

  比如下面的参数就是设置老年代与新生代内存的比值为 1。也就是说老年代和新生代所占比值为 1：1，新生代占整个堆栈的 1/2。
  -XX:NewRatio=1
  复制

• 显式指定永久代/元空间的大小 ：Metaspace 的初始容量并不是 -XX:MetaspaceSize 设置，无论 -XX:MetaspaceSize 配置什么值，对于 64 位 JVM 来说，Metaspace 的初始容量都是 21807104（约 20.8m）。

  JDK 1.8 之前
  -XX:PermSize=N #方法区 (永久代) 初始大小
  -XX:MaxPermSize=N #方法区 (永久代) 最大大小,超过这个值将会抛出 OutOfMemoryError 异常:java.lang.OutOfMemoryError: PermGen  
  JDK 1.8 
  -XX:MetaspaceSize=N #设置 Metaspace 的初始大小（是一个常见的误区，后面会解释）
  -XX:MaxMetaspaceSize=N #设置 Metaspace 的最大大小
   
  复制

• 垃圾回收器JVM 具有四种类型的 GC 实现：

  • 串行垃圾收集器

  • 并行垃圾收集器

  • CMS 垃圾收集器

  • G1 垃圾收集器

可以使用以下参数声明这些实现：

-XX:+UseSerialGC
-XX:+UseParallelGC
-XX:+UseConcMarkSweepGC
-XX:+UseG1GC

复制

• GC日志记录

# 必选
# 打印基本 GC 信息
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
# 打印对象分布
-XX:+PrintTenuringDistribution
# 打印堆数据
-XX:+PrintHeapAtGC
# 打印Reference处理信息
# 强引用/弱引用/软引用/虚引用/finalize 相关的方法
-XX:+PrintReferenceGC
# 打印STW时间
-XX:+PrintGCApplicationStoppedTime

# 可选
# 打印safepoint信息，进入 STW 阶段之前，需要要找到一个合适的 safepoint
-XX:+PrintSafepointStatistics
-XX:PrintSafepointStatisticsCount=1

# GC日志输出的文件路径
-Xloggc:/path/to/gc-%t.log
# 开启日志文件分割
-XX:+UseGCLogFileRotation
# 最多分割几个文件，超过之后从头文件开始写
-XX:NumberOfGCLogFiles=14
# 每个文件上限大小，超过就触发分割
-XX:GCLogFileSize=50M

复制

对于大型应用程序来说，面对内存不足错误是非常常见的，这反过来会导致应用程序崩溃。这是一个非常关键的场景，很难通过复制来解决这个问题。

这就是为什么 JVM 提供了一些参数，这些参数将堆内存转储到一个物理文件中，以后可以用来查找泄漏:

-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./java_pid<pid>.hprof
-XX:OnOutOfMemoryError="< cmd args >;< cmd args >"
-XX:+UseGCOverheadLimit
复制

这里有几点需要注意:

• HeapDumpOnOutOfMemoryError 指示 JVM 在遇到 OutOfMemoryError 错误时将 heap 转储到物理文件中。
• HeapDumpPath 表示要写入文件的路径; 可以给出任何文件名; 但是，如果 JVM 在名称中找到一个 <pid> 标记，则当前进程的进程 id 将附加到文件名中，并使用.hprof格式
• OnOutOfMemoryError 用于发出紧急命令，以便在内存不足的情况下执行; 应该在 cmd args 空间中使用适当的命令。例如，如果我们想在内存不足时重启服务器，我们可以设置参数: -XX:OnOutOfMemoryError="shutdown -r" 。
• UseGCOverheadLimit 是一种策略，它限制在抛出 OutOfMemory 错误之前在 GC 中花费的 VM 时间的比例

• -server : 启用“ Server Hotspot VM”; 此参数默认用于 64 位 JVM

• -XX:+UseStringDeduplication : Java 8u20 引入了这个 JVM 参数，通过创建太多相同 String 的实例来减少不必要的内存使用; 这通过将重复 String 值减少为单个全局 char [] 数组来优化堆内存。

• -XX:+UseLWPSynchronization: 设置基于 LWP (轻量级进程)的同步策略，而不是基于线程的同步。

• -XX:LargePageSizeInBytes: 设置用于 Java 堆的较大页面大小; 它采用 GB/MB/KB 的参数; 页面大小越大，我们可以更好地利用虚拟内存硬件资源; 然而，这可能会导致 PermGen 的空间大小更大，这反过来又会迫使 Java 堆空间的大小减小。

• -XX:MaxHeapFreeRatio : 设置 GC 后, 堆空闲的最大百分比，以避免收缩。

• -XX:SurvivorRatio : eden/survivor 空间的比例, 例如-XX:SurvivorRatio=6 设置每个 survivor 和 eden 之间的比例为 1:6。

• -XX:+UseLargePages : 如果系统支持，则使用大页面内存; 请注意，如果使用这个 JVM 参数，OpenJDK 7 可能会崩溃。

• -XX:+UseStringCache : 启用 String 池中可用的常用分配字符串的缓存。

• -XX:+UseCompressedStrings : 对 String 对象使用 byte [] 类型，该类型可以用纯 ASCII 格式表示。

• -XX:+OptimizeStringConcat : 它尽可能优化字符串串联操作。

这些命令在 JDK 安装目录下的 bin 目录下：

• jps (JVM Process Status）: 类似 UNIX 的 ps 命令。用于查看所有 Java 进程的启动类、传入参数和 Java 虚拟机参数等信息；
• jstat（JVM Statistics Monitoring Tool）: 用于收集 HotSpot 虚拟机各方面的运行数据;
• jinfo (Configuration Info for Java) : Configuration Info for Java,显示虚拟机配置信息;
• jmap (Memory Map for Java) : 生成堆转储快照;
• jhat (JVM Heap Dump Browser) : 用于分析 heapdump 文件，它会建立一个 HTTP/HTML 服务器，让用户可以在浏览器上查看分析结果。JDK9 移除了 jhat；
• jstack (Stack Trace for Java) : 生成虚拟机当前时刻的线程快照，线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合。

https://javaguide.cn/java/jvm/jdk-monitoring-and-troubleshooting-tools.html#jconsole-java-%E7%9B%91%E8%A7%86%E4%B8%8E%E7%AE%A1%E7%90%86%E6%8E%A7%E5%88%B6%E5%8F%B0

• JConsole 是基于 JMX 的可视化监视、管理工具。可以很方便的监视本地及远程服务器的 java 进程的内存使用情况。你可以在控制台输入jconsole命令启动或者在 JDK 目录下的 bin 目录找到jconsole.exe然后双击启动。
• VisualVM 提供在 Java 虚拟机 (Java Virtual Machine, JVM) 上运行的 Java 应用程序的详细信息。
• MAT（Memory Analyzer Tool）是一款快速便捷且功能强大丰富的 JVM 堆内存离线分析工具。其通过展现 JVM 异常时所记录的运行时堆转储快照（Heap dump）状态（正常运行时也可以做堆转储分析），帮助定位内存泄漏问题或优化大内存消耗逻辑。